EDMA.c

Go to the documentation of this file.

#include "derivative.h"
#include "edma.h"
/*
 ******************************************************************************
 * Constants
 ******************************************************************************
 */
const uint32_t cu32DMACopyArrayTCD[] =
{
  (uint32_t)CLEAR, 
  (DMA_8_BIT_SOURCE | DMA_8_BIT_TARGET | DMA_OFFSET(1u)),
  (uint32_t)CLEAR, 
  (uint32_t)CLEAR, 
  (uint32_t)CLEAR,
  (CHANNEL_TO_CHANNEL_LINKING_ON_MINOR_LOOP_DIS | CURRENT_MAJOR_ITERATION(1u)
      | DMA_OFFSET(1u)), 
  (uint32_t)CLEAR,
  (CHANNEL_TO_CHANNEL_LINKING_ON_MAJOR_LOOP_DIS
      | NUMBER_OF_MAJOR_ITERATIONS(1u) | DONT_STALL_DMA | DMA_ISR_WHEN_DONE) };
/*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
/*
 ******************************************************************************
 * vfnDMASet
 ******************************************************************************
 */
void vfnDMASet(uint8_t u8Chan, uint8_t *pu8DestAddr, uint8_t *pu8SourceAddr,
               uint16_t u16NOfBytes)
{
  /* clear done flag */
  EDMA.CDSBR.R = u8Chan;
  /* copy bytes to buffer ->  use DMA */
  EDMA.TCD[u8Chan].CITER = u16NOfBytes;
  EDMA.TCD[u8Chan].BITER = u16NOfBytes;
  /* set destination */
  EDMA.TCD[u8Chan].DADDR = (uint32_t)pu8DestAddr;
  /* set source */
  EDMA.TCD[u8Chan].SADDR = (uint32_t)pu8SourceAddr;
  
  return;
}
/*
 ******************************************************************************
 * vfnDMAConfig
 ******************************************************************************
 */
void vfnDMAConfig(TCD_t *ptMyTCD, uint8_t u8Channel)
{
  /* Configure DMA Channel TCD  */
  EDMA.TCD[u8Channel].SADDR = ptMyTCD->P.SADDR;
  EDMA.TCD[u8Channel].SMOD = ptMyTCD->P.SMOD;
  EDMA.TCD[u8Channel].SSIZE = ptMyTCD->P.SSIZE;
  EDMA.TCD[u8Channel].DMOD = ptMyTCD->P.DMOD;
  EDMA.TCD[u8Channel].DSIZE = ptMyTCD->P.DSIZE;
  EDMA.TCD[u8Channel].SOFF = ptMyTCD->P.SOFF;
  EDMA.TCD[u8Channel].NBYTES = ptMyTCD->P.NBYTES;
  EDMA.TCD[u8Channel].SLAST = ptMyTCD->P.SLAST;
  EDMA.TCD[u8Channel].DADDR = ptMyTCD->P.DADDR;
  EDMA.TCD[u8Channel].CITERE_LINK = ptMyTCD->P.CITERE_LINK;
  EDMA.TCD[u8Channel].CITER = ptMyTCD->P.CITER;
  EDMA.TCD[u8Channel].DOFF = ptMyTCD->P.DOFF;
  EDMA.TCD[u8Channel].DLAST_SGA = ptMyTCD->P.DLAST_SGA;
  EDMA.TCD[u8Channel].BITERE_LINK = ptMyTCD->P.BITERE_LINK;
  EDMA.TCD[u8Channel].BITER = ptMyTCD->P.BITER;
  EDMA.TCD[u8Channel].BWC = ptMyTCD->P.BWC;
  EDMA.TCD[u8Channel].MAJORLINKCH = ptMyTCD->P.MAJORLINKCH;
  EDMA.TCD[u8Channel].DONE = ptMyTCD->P.DONE;
  EDMA.TCD[u8Channel].ACTIVE = ptMyTCD->P.ACTIVE;
  EDMA.TCD[u8Channel].MAJORE_LINK = ptMyTCD->P.MAJORE_LINK;
  EDMA.TCD[u8Channel].E_SG = ptMyTCD->P.E_SG;
  EDMA.TCD[u8Channel].D_REQ = ptMyTCD->P.D_REQ;
  EDMA.TCD[u8Channel].INT_HALF = ptMyTCD->P.INT_HALF;
  EDMA.TCD[u8Channel].INT_MAJ = ptMyTCD->P.INT_MAJ;
  EDMA.TCD[u8Channel].START = ptMyTCD->P.START;
  
  return;
}
/*
 ******************************************************************************
 * vfnDMAStart
 ******************************************************************************
 */
void vfnDMAStart(const uint8_t u8Chan)
{
  /* Clear any "Done flags */
  EDMA.TCD[u8Chan].DONE = CLEAR;
  /* start dma channel */
  EDMA.TCD[u8Chan].START = TRUE;
  
  return;
}
/*
 ******************************************************************************
 * vfnDMAEnable
 ******************************************************************************
 */
void vfnDMAEnable(const uint8_t u8Chan)
{
  /* enable dma channel */
  EDMA.SERQR.R = u8Chan;
  
  return;
}
/*
 ******************************************************************************
 * u8fnDMAPending
 ******************************************************************************
 */
uint8_t u8fnDMAPending(const uint8_t u8Chan)
{
  return ((uint8_t)EDMA.TCD[u8Chan].DONE);
}
/*
 ******************************************************************************
 * u8fnDMACopyArray
 ******************************************************************************
 */
void vfnDMACopyArray(uint8_t* pu8Source, uint8_t* pu8Target, uint16_t u16Size,
                     uint8_t u8Channel)
{
  uint8_t u8Status;
  uint8_t u8Counter;
  TCD_t tMyConfig;
  
  /* Init Local Variables */
  u8Status = CLEAR;
  
  /* Load defaults */
  for(u8Counter = CLEAR; u8Counter < N_ELEMENTS(cu32DMACopyArrayTCD); u8Counter++)
  {
    tMyConfig.A.SETTINGS[u8Counter] = cu32DMACopyArrayTCD[u8Counter];
  }

  /* Load particular settings for this transfer */
  tMyConfig.P.NBYTES = u16Size;
  tMyConfig.P.SADDR = (uint32_t)pu8Source;
  tMyConfig.P.DADDR = (uint32_t)pu8Target;
  
  /* Load settings to DMA */
  vfnDMAConfig((TCD_t*)&tMyConfig, u8Channel);
  
  /* Enable the channel */
  vfnDMAEnable(u8Channel);
  
  /* Start the channel */
  vfnDMAStart(u8Channel);
  
  return;
}
/*
 ******************************************************************************
 * vfnDMAPersonalizeChannel
 ******************************************************************************
 */
//void vfnDMAPersonalizeChannel(const uint8_t u8DMAChannel, const uint16_t* pu16Destination,
//                              const uint16_t* pu16Source, const uint16_t u16Size)
//{
//  /* Source address is the inbox + the offset */
//  EDMA.TCD[u8DMAChannel].SADDR = (uint32_t)(pu16Source);
//  /* Destination address is our passed pointer */
//  EDMA.TCD[u8DMAChannel].DADDR = (uint32_t)pu16Destination;
//  /* Number of bytes is given by the passed variable * 2 */
//  /* (passed variable is in u16) */
//  EDMA.TCD[u8DMAChannel].NBYTES = (uint32_t)(u16Size);
//  /* Allow HW linking to the next channel - reset after tx */
//  EDMA.TCD[u8DMAChannel].MAJORE_LINK = TRUE;
//  
//  return;
//}
/*
 ******************************************************************************
 * u8fnWaitForDMA
 ******************************************************************************
 */
uint8_t u8fnWaitForDMA(uint8_t u8Channel)
{
  uint8_t u8Status;
  uint16_t u16TimeOut;
  
  /* Init locals */
  u8Status = CLEAR;
  u16TimeOut = 0xFFFFu;
  
  /* Wait for the Major Loop to be completed */
  while((DMA_COMPLETED_MAJOR_LOOP != u8fnDMAReturnChannelStatus(u8Channel))
      && u16TimeOut--)
  {
    /* Wait here */
  };

  if(CLEAR == u16TimeOut)
  {
    /* We timed-out */
    u8Status = TRUE;
  }
  else
  {
    /* Let's go */
  }
  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnDMAReturnChannelStatus
 ******************************************************************************
 */
uint8_t u8fnDMAReturnChannelStatus(uint8_t u8Channel)
{
  /* Local variables */
  uint8_t u8Status;
  
  u8Status = CLEAR;
  
  /* Based on the condition of START, Active and DONE, determine the state */
  if(TRUE == EDMA.TCD[u8Channel].START)
  {
    u8Status = DMA_SERVICE_REQUEST_ASSERTED;
  }
  else
  {
    if(TRUE == EDMA.TCD[u8Channel].ACTIVE)
    {
      u8Status = DMA_EXECUTING;
    }
    else
    {
      if(TRUE == EDMA.TCD[u8Channel].DONE)
      {
        u8Status = DMA_COMPLETED_MAJOR_LOOP;
      }
      else
      {
        u8Status = DMA_COMPLETED_MINOR_LOOP;
      }
    }
  }
  
  /* Return state */
  return (u8Status);
}
/*
 ******************************************************************************
 * vfnDMAMUXInit
 ******************************************************************************
 */
void vfnDMAMUXInit(uint8_t u8DMACh, uint8_t u8DMAMuxSource, uint8_t u8Trigger, uint8_t u8Enable)
{
  DMAMUX.CHCONFIG[u8DMACh].B.SOURCE = u8DMAMuxSource;
  DMAMUX.CHCONFIG[u8DMACh].B.TRIG = u8Trigger;
  DMAMUX.CHCONFIG[u8DMACh].B.ENBL = u8Enable;
  
  return;
}
/*
 ******************************************************************************
 * vfnDMAMuxEnable
 ******************************************************************************
 */
void vfnDMAMuxEnable(uint8_t u8DMACh, uint8_t u8Enable)
{
  DMAMUX.CHCONFIG[u8DMACh].B.ENBL = u8Enable;
  return;
}
/*
 ******************************************************************************
 * u8fnDMAMuxChEnStatus
 ******************************************************************************
 */
uint8_t u8fnDMAMuxChEnStatus(uint8_t u8DMACh)
{
  return(DMAMUX.CHCONFIG[u8DMACh].B.ENBL);
}
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */